home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / misc_src / cslib16b / demo / address / csaddio.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-01  |  22.5 KB  |  724 lines
  1. /////////////////////////////////////////////////////////
  2. //     Implementation file of database class: NAM_foundation.
  3. //                                                          
  4. //     Source generated by: CSDBGEN version 1.2.b.
  5. //     Date of generation:  Thursday, 2 March 1995.
  6. //     Time of generation:  12:00:12.
  7. //                                                          
  8. //                                                          
  9. //     The next lines represent the database definition     
  10. //     file used as input for CSDBGEN.                      
  11. //                                                          
  12. //                                                          
  13. ////////////// Start of the .def file //////////////////
  14. /*
  15. class: NAM_foundation
  16. record: record
  17. file: csadr.dbf
  18. field: name s 40 T
  19. field: adre s 32
  20. field: city s 23 Y
  21. field: count s 32
  22. field: zip s 9
  23. field: tel s 17
  24. field: update d MDY2
  25. field: birth d DMY4 Y
  26. field: relation s 10 Y
  27. field: info s 70
  28. */
  29. /////////////// End of .def file //////////////////////////////////////////////
  30. /*
  31.  
  32.  
  33.  
  34.                  █████     █                       █        
  35.                 ██   ██   ██                      ██        
  36.                 ███      ████     ███   ██ ███   ████       
  37.                   ███     ██        ██   ███ ██   ██        
  38.                     ███   ██     █████   ██       ██        
  39.                 ██   ██   ██ █  ██  ██   ██       ██ █      
  40.                  █████     ██    ███ ██  ██        ██       
  41.                                                             
  42.                                                             
  43.              ████     ████  ██  ██  ██ ███   █████   ████   
  44.             ██       ██  ██ ██  ██   ███ ██ ██   █  ██  ██  
  45.              ████    ██  ██ ██  ██   ██     ██      ██████  
  46.                 ██   ██  ██ ██  ██   ██     ██   █  ██      
  47.              ████     ████   ███ ██  ██      █████   █████  
  48.                                                             
  49.  
  50.  
  51. */
  52. //////////////////////////////////////////////////////////////////////////////
  53.  
  54. #include "csaddio.h"
  55.  
  56. extern unsigned _stklen=7000;  //A large stack is needed
  57.  
  58.  
  59. ///////////////////////////////// Constructor ////////////////////////////////
  60. NAM_foundation::NAM_foundation(void) 
  61. { 
  62.     is_open=FALSE; 
  63.     current=1; 
  64.     _update.format(MDY2); 
  65.     _birth.format(DMY4); 
  66. }
  67.  
  68. ///////////////////////////////// reindex ////////////////////////////////////
  69. void NAM_foundation::reindex(void) 
  70. {
  71.     U32 l=current;  
  72.     record *rp;  
  73.     in1.empty(); 
  74.     in2.empty(); 
  75.     in3.empty(); 
  76.     in4.empty(); 
  77.     for(current=numrec(); current>0; current--)  
  78.     {                          
  79.        rp=(record *)db.locate_rec(current);  
  80.        tokenize(rp->_name,&NAM_foundation::in1_ins_tok); 
  81.        in2.insert(rp->_city,¤t); 
  82.        in3.insert(&rp->__birth,¤t); 
  83.        in4.insert(rp->_relation,¤t); 
  84.     }                          
  85.     current=l;                 
  86. }
  87.  
  88. /////////////// go_to ////////////////////////////////////////////
  89. void NAM_foundation::go_to(long n) 
  90. {
  91.     if(order()!=UNSORTED) 
  92.     {
  93.       csmess_p(7110,"NAM_foundation"); 
  94.       return; 
  95.     }
  96.     write_rec(); 
  97.     current=max(min(n,db.numrec()),1); 
  98.     read_rec(); 
  99. }
  100.  
  101. /////////////// append blank//////////////////////////////////////
  102. void NAM_foundation::append_blank(void) 
  103. {
  104.        append();
  105.        tokenize(recp->_name,&NAM_foundation::in1_ins_tok); 
  106.        in2.insert(rec._city,¤t); 
  107.        in3.insert(&rec.__birth,¤t); 
  108.        in4.insert(rec._relation,¤t); 
  109. }
  110.  
  111. ///////////////////////////////// append /////////////////////////////////////
  112. // This function doesn't update the indexes, which can save some 
  113. // disk I/O because you are likely to alter the fields 
  114. // immediately after you have appended the record.
  115. // However, if you have an index on a field you don't update, this 
  116. // record will NOT appear in that particular index! 
  117. // The 'append_blank' function does update all indexes, which 
  118. // makes it a safer, but slower option. 
  119. //  
  120. void NAM_foundation::append(void) 
  121. {
  122.     write_rec();
  123.     memset(&rec,0,sizeof(record)); 
  124.     current=db.append_rec(&rec); 
  125.     recp=(record *)db.locate_rec(current); 
  126.     dirty=TRUE;    
  127.     _update.sem_jul(0L);
  128.     _birth.sem_jul(0L);
  129. }
  130.  
  131. ///////////////////////////////// open ///////////////////////////////////////
  132. void NAM_foundation::open(void) 
  133. {
  134.      if(is_open) return; 
  135.      int needs_reindex=FALSE;        
  136.      dirty=FALSE;        
  137.  
  138. #ifdef _Windows
  139.      int fre=300/9; //Use 300 Kb for buffers. You may increase this.
  140. #else
  141.      int fre=(int)(coreleft()-100000L)/9/1024;
  142.      fre=max(fre,0); 
  143. #endif
  144.  
  145.      if(!db.open("csadr.dbf",fre)) 
  146.      {
  147.          csmess_disp("FATAL: Can't open database csadr.dbf.");
  148.          exit(1);
  149.      }
  150.      if(db.lengthrec()!=sizeof(record)) 
  151.      {
  152.          csmess_disp("FATAL: wrong record size.\n\rProbably wrong or old database file.");
  153.          db.close(); 
  154.          exit(1); 
  155.      }
  156.      if(!file_exist("csadr01.idx"))
  157.      { 
  158.        in1.multiple_keys(TRUE);
  159.        in1.define("csadr01.idx",NAME_LENGTH/2,sizeof(long));
  160.        needs_reindex=TRUE; 
  161.      } 
  162.      in1.open("csadr01.idx",fre*2);
  163.   
  164.      if(!file_exist("csadr02.idx"))
  165.      { 
  166.        in2.multiple_keys(TRUE);
  167.        in2.define("csadr02.idx",CITY_LENGTH+1,sizeof(long));
  168.        needs_reindex=TRUE; 
  169.      } 
  170.      in2.open("csadr02.idx",fre*2);
  171.   
  172.      if(!file_exist("csadr03.idx"))
  173.      { 
  174.        in3.multiple_keys(TRUE);
  175.        in3.define("csadr03.idx",sizeof(long),sizeof(long));
  176.        needs_reindex=TRUE; 
  177.      } 
  178.      in3.open("csadr03.idx",fre*2);
  179.   
  180.      if(!file_exist("csadr04.idx"))
  181.      { 
  182.        in4.multiple_keys(TRUE);
  183.        in4.define("csadr04.idx",RELATION_LENGTH+1,sizeof(long));
  184.        needs_reindex=TRUE; 
  185.      } 
  186.      in4.open("csadr04.idx",fre*2);
  187.   
  188.      if(needs_reindex) reindex(); 
  189.      is_open=TRUE; 
  190.      if(numrec()==0) append_blank();
  191.      else            read_rec(); 
  192.   
  193.      order(UNSORTED);  
  194. }
  195.  
  196. ///////////////////////////////// close //////////////////////////////////////
  197. void NAM_foundation::close(void) 
  198. {
  199.      if(!is_open) return; 
  200.      write_rec(); 
  201.      db.close(); 
  202.      in1.close();
  203.      in2.close();
  204.      in3.close();
  205.      in4.close();
  206.      is_open=FALSE; 
  207. }
  208.  
  209. ///////////////////////////////// define /////////////////////////////////////
  210. void NAM_foundation::define(void) 
  211. {
  212.      db.define("csadr.dbf",sizeof(record)); 
  213.      in1.multiple_keys(TRUE);
  214.      in1.define("csadr01.idx",NAME_LENGTH/2,sizeof(long));
  215.      in2.multiple_keys(TRUE);
  216.      in2.define("csadr02.idx",CITY_LENGTH+1,sizeof(long));
  217.      in3.multiple_keys(TRUE);
  218.      in3.define("csadr03.idx",sizeof(long),sizeof(long));
  219.      in4.multiple_keys(TRUE);
  220.      in4.define("csadr04.idx",RELATION_LENGTH+1,sizeof(long));
  221. }
  222.  
  223. ///////////////////////////////// pack ///////////////////////////////////////
  224. void NAM_foundation::pack(void) 
  225. {
  226.      write_rec(); 
  227.      db.pack();
  228.      reindex();
  229.      if(numrec()==0) append_blank();
  230.      top();
  231. }
  232.  
  233. ///////////////////////////////// skip ///////////////////////////////////////
  234. int  NAM_foundation::skip0(int delta) 
  235. {
  236.      long old_current=current; 
  237.      current=max(min(current+delta,db.numrec()),1); 
  238.      return current-old_current; 
  239. }
  240.  
  241. int  NAM_foundation::skip(int delta) 
  242. {
  243.      int rc; 
  244.      write_rec(); 
  245.      rc=(this->*skip_fun)(delta); 
  246.      read_rec(); 
  247.      return rc; 
  248. }
  249.  
  250. ///////////////////////////////// order //////////////////////////////////////
  251. void NAM_foundation::order(int nr) 
  252. {
  253.      switch(nr)
  254.      {
  255.          case 0:        //Unsorted 
  256.                   bof_fun   =&NAM_foundation::bof0;
  257.                   eof_fun   =&NAM_foundation::eof0;
  258.                   skip_fun  =&NAM_foundation::skip0;
  259.                   top_fun   =&NAM_foundation::top0;
  260.                   bottom_fun=&NAM_foundation::bottom0;
  261.                   search_fun=&NAM_foundation::search0;
  262.                   break; 
  263.          case 1:        //Index on field name
  264.                   bof_fun   =&NAM_foundation::bof1;
  265.                   eof_fun   =&NAM_foundation::eof1;
  266.                   skip_fun  =&NAM_foundation::skip1;
  267.                   top_fun   =&NAM_foundation::top1;
  268.                   bottom_fun=&NAM_foundation::bottom1;
  269.                   search_fun=&NAM_foundation::search1;
  270.                   break; 
  271.          case 2:        //Index on field city
  272.                   bof_fun   =&NAM_foundation::bof2;
  273.                   eof_fun   =&NAM_foundation::eof2;
  274.                   skip_fun  =&NAM_foundation::skip2;
  275.                   top_fun   =&NAM_foundation::top2;
  276.                   bottom_fun=&NAM_foundation::bottom2;
  277.                   search_fun=&NAM_foundation::search2;
  278.                   break; 
  279.          case 3:        //Index on field birth
  280.                   bof_fun   =&NAM_foundation::bof3;
  281.                   eof_fun   =&NAM_foundation::eof3;
  282.                   skip_fun  =&NAM_foundation::skip3;
  283.                   top_fun   =&NAM_foundation::top3;
  284.                   bottom_fun=&NAM_foundation::bottom3;
  285.                   search_fun=&NAM_foundation::search3;
  286.                   break; 
  287.          case 4:        //Index on field relation
  288.                   bof_fun   =&NAM_foundation::bof4;
  289.                   eof_fun   =&NAM_foundation::eof4;
  290.                   skip_fun  =&NAM_foundation::skip4;
  291.                   top_fun   =&NAM_foundation::top4;
  292.                   bottom_fun=&NAM_foundation::bottom4;
  293.                   search_fun=&NAM_foundation::search4;
  294.                   break; 
  295.          default: return; // Function called with wrong parameter.
  296.      }
  297.      iOrder=nr;
  298.      top();
  299. }
  300. /////////////////////////////writing record  ///////////////////////////////
  301. void NAM_foundation::write_rec2(void) 
  302. {
  303.     if(strcmp(recp->_name,rec._name)) 
  304.     { 
  305.       tokenize(recp->_name,&NAM_foundation::in1_del_tok); 
  306.       tokenize(rec._name,&NAM_foundation::in1_ins_tok); 
  307.     } 
  308.     if(strcmp(recp->_city,rec._city)) 
  309.     { 
  310.       in2.delet(recp->_city,¤t); 
  311.       in2.insert(rec._city,¤t); 
  312.     } 
  313.     rec.__update=_update.sem_jul(); 
  314.     rec.__birth=_birth.sem_jul(); 
  315.     if(recp->__birth!=rec.__birth) 
  316.     { 
  317.       in3.delet(&recp->__birth,¤t); 
  318.       in3.insert(&rec.__birth,¤t); 
  319.     } 
  320.     if(strcmp(recp->_relation,rec._relation)) 
  321.     { 
  322.       in4.delet(recp->_relation,¤t); 
  323.       in4.insert(rec._relation,¤t); 
  324.     } 
  325.     db.write_rec(current,&rec); 
  326.     dirty=FALSE;   
  327. }
  328.  
  329. ///////////////////////////////// export /////////////////////////////////////
  330. int  NAM_foundation::export(char *s) 
  331. {
  332.      FILE *fo=fopen(s,"w"); 
  333.      if(fo==NULL) return FALSE; 
  334.  
  335.      write_rec();
  336.      fprintf(fo,"class:  NAM_foundation");
  337.      fprintf(fo,"\nrecord: record");
  338.      fprintf(fo,"\nfile:   csadr.dbf");
  339.      fprintf(fo,"\nfield:  name s 40 Y");
  340.      fprintf(fo,"\nfield:  adre s 32  ");
  341.      fprintf(fo,"\nfield:  city s 23 Y");
  342.      fprintf(fo,"\nfield:  count s 32  ");
  343.      fprintf(fo,"\nfield:  zip s 9  ");
  344.      fprintf(fo,"\nfield:  tel s 17  ");
  345.      fprintf(fo,"\nfield:  update d  ");
  346.      fprintf(fo,"\nfield:  birth d Y");
  347.      fprintf(fo,"\nfield:  relation s 10 Y");
  348.      fprintf(fo,"\nfield:  info s 70  ");
  349.  
  350.      if(ferror(fo)) { fclose(fo); return FALSE; } 
  351.  
  352.      record *recp;
  353.      DATE conv;
  354.      conv.format(Y4MD);
  355.      for(long l=numrec();l>0;l--) 
  356.      {
  357.         recp=( record * )db.locate_rec(l);
  358.         fprintf(fo,"\n%c",12);
  359.         fprintf(fo,"\n%s",recp->_name);
  360.         fprintf(fo,"\n%s",recp->_adre);
  361.         fprintf(fo,"\n%s",recp->_city);
  362.         fprintf(fo,"\n%s",recp->_count);
  363.         fprintf(fo,"\n%s",recp->_zip);
  364.         fprintf(fo,"\n%s",recp->_tel);
  365.         conv.sem_jul(recp->__update);
  366.         fprintf(fo,"\n%s",(char *)conv);
  367.         conv.sem_jul(recp->__birth);
  368.         fprintf(fo,"\n%s",(char *)conv);
  369.         fprintf(fo,"\n%s",recp->_relation);
  370.         fprintf(fo,"\n%s",recp->_info);
  371.         fprintf(fo,"\n"); //Additional linefeed, to avoid trouble!
  372.  
  373.         if(ferror(fo)) { fclose(fo); return FALSE; } 
  374.      }
  375.      return !fclose(fo);  
  376. }
  377.  
  378. ///////////////////////////////// import /////////////////////////////////////
  379. int NAM_foundation::import(char *s) 
  380. {   
  381.  
  382.       FILE *fr=fopen(s,"r"); 
  383.       if(fr==NULL) return FALSE;
  384.   
  385.   
  386. #define MAX_NUM_FIELDS  100   //Increase this to allow more fields    
  387. #define MAX_FIELD_LEN   500   //Increase this to allow longer fields  
  388.  
  389.       int *finu;
  390.       finu=(int *)malloc(MAX_NUM_FIELDS*sizeof(int));
  391.       if(finu==NULL) { fclose(fr); return FALSE; }   
  392.  
  393.       char *fibu;    
  394.       fibu=(char *)malloc(MAX_FIELD_LEN);
  395.       if(fibu==NULL) { fclose(fr); free(finu); return FALSE; } 
  396.       *fibu=0;  
  397.  
  398.       char *fipo=fibu+strlen("field:");  
  399.       char *cp; 
  400.       int  ifieldnr=0;    
  401.       int  ofieldnr; 
  402.       DATE conv;
  403.       conv.format(Y4MD);
  404.  
  405.       memset(finu,0,MAX_NUM_FIELDS*sizeof(int));
  406.  
  407.       fgets(fibu,MAX_FIELD_LEN,fr); 
  408.       while(!strchr(fibu,12))  
  409.       {    
  410.         strlwr(fibu);
  411.         notabs(fibu);
  412.         trim_string(fibu);
  413.         if(strstr(fibu,"field:"))   
  414.         {  
  415.            ifieldnr++;  
  416.            trim_string(fipo);    
  417.            if((cp=strchr(fipo,' '))!=NULL) *cp=0;
  418.            if     (!strcmp(fipo,"name"))    ofieldnr=1;
  419.            else if(!strcmp(fipo,"adre"))    ofieldnr=2;
  420.            else if(!strcmp(fipo,"city"))    ofieldnr=3;
  421.            else if(!strcmp(fipo,"count"))    ofieldnr=4;
  422.            else if(!strcmp(fipo,"zip"))    ofieldnr=5;
  423.            else if(!strcmp(fipo,"tel"))    ofieldnr=6;
  424.            else if(!strcmp(fipo,"update"))    ofieldnr=7;
  425.            else if(!strcmp(fipo,"birth"))    ofieldnr=8;
  426.            else if(!strcmp(fipo,"relation"))    ofieldnr=9;
  427.            else if(!strcmp(fipo,"info"))    ofieldnr=10;
  428.            else ofieldnr=0; 
  429.            finu[ifieldnr]=ofieldnr; 
  430.         }  
  431.         fgets(fibu,MAX_FIELD_LEN,fr);    
  432.       }    
  433.  
  434.  
  435.  
  436.       for(;;)   
  437.       {    
  438.         if(!strchr(fibu,12))   
  439.         {  
  440.            ifieldnr++; 
  441.            if(ifieldnr<MAX_NUM_FIELDS) 
  442.              switch(finu[ifieldnr])   
  443.              {  
  444.                 case 0:  break;
  445.                 case 1:
  446.                          fibu[NAME_LENGTH]=0;
  447.                          name(fibu);
  448.                          break;
  449.                 case 2:
  450.                          fibu[ADRE_LENGTH]=0;
  451.                          adre(fibu);
  452.                          break;
  453.                 case 3:
  454.                          fibu[CITY_LENGTH]=0;
  455.                          city(fibu);
  456.                          break;
  457.                 case 4:
  458.                          fibu[COUNT_LENGTH]=0;
  459.                          count(fibu);
  460.                          break;
  461.                 case 5:
  462.                          fibu[ZIP_LENGTH]=0;
  463.                          zip(fibu);
  464.                          break;
  465.                 case 6:
  466.                          fibu[TEL_LENGTH]=0;
  467.                          tel(fibu);
  468.                          break;
  469.                 case 7:
  470.                          conv=fibu;
  471.                          _update.sem_jul(conv.sem_jul());
  472.                          break;
  473.                 case 8:
  474.                          conv=fibu;
  475.                          _birth.sem_jul(conv.sem_jul());
  476.                          break;
  477.                 case 9:
  478.                          fibu[RELATION_LENGTH]=0;
  479.                          relation(fibu);
  480.                          break;
  481.                 case 10:
  482.                          fibu[INFO_LENGTH]=0;
  483.                          info(fibu);
  484.                          break;
  485.              }  
  486.         }  
  487.         else    
  488.         {  
  489.            ifieldnr=0; 
  490.            append_blank();
  491.         }  
  492.         if(feof(fr)) break;    
  493.         fgets(fibu,MAX_FIELD_LEN,fr);    
  494.         cp=fibu+(max(1,strlen(fibu))-1); 
  495.         if(*cp=='\n') *cp=0;  //removing the line feed 
  496.       }    
  497.  
  498.  
  499.       fclose(fr); 
  500.       free(fibu); 
  501.       free(finu); 
  502.  
  503. #undef MAX_NUM_FIELDS
  504. #undef MAX_FIELD_LEN 
  505.  
  506.  return TRUE; 
  507. }
  508.  
  509. ///////////////////////////////// export to dBASE compatible file. ///////////
  510. int NAM_foundation::to_DBASE(char *s) 
  511. {   
  512.  
  513.       char bufje[12];
  514.       if(!is_open) return FALSE;
  515.  
  516.       write_rec(); 
  517.       FILE *fo=fopen(s,"wb"); 
  518.       if(fo==NULL) return FALSE;
  519.   
  520.       int i;
  521.   
  522.       DATE d_upda;
  523.       d_upda.sem_jul(db.sj_updated());
  524.       fputc(03,fo);  
  525.       
  526.       fputc(d_upda.year()%100,fo);  
  527.       fputc(d_upda.month(),fo);  
  528.       fputc(d_upda.day(),fo);  
  529.  
  530.       long nr_record=numrec(); 
  531.       fwrite(&nr_record,sizeof(long),1,fo); 
  532.       putw(354,fo);        //Header length 
  533.       putw(250,fo);        //Length of data record 
  534.       for(i=0;i<20;i++) fputc(0,fo); // 20 dummy bytes 
  535.  
  536.  
  537. // Writing definition of field name to dbase file header.
  538.       memset(bufje,0,11);
  539.       strcpy(bufje,"NAME");
  540.       fwrite(bufje,11,1,fo);
  541.       fputc('C',fo); 
  542.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  543.       fputc(40,fo); 
  544.       fputc(0,fo); 
  545.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  546.  
  547. // Writing definition of field adre to dbase file header.
  548.       memset(bufje,0,11);
  549.       strcpy(bufje,"ADRE");
  550.       fwrite(bufje,11,1,fo);
  551.       fputc('C',fo); 
  552.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  553.       fputc(32,fo); 
  554.       fputc(0,fo); 
  555.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  556.  
  557. // Writing definition of field city to dbase file header.
  558.       memset(bufje,0,11);
  559.       strcpy(bufje,"CITY");
  560.       fwrite(bufje,11,1,fo);
  561.       fputc('C',fo); 
  562.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  563.       fputc(23,fo); 
  564.       fputc(0,fo); 
  565.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  566.  
  567. // Writing definition of field count to dbase file header.
  568.       memset(bufje,0,11);
  569.       strcpy(bufje,"COUNT");
  570.       fwrite(bufje,11,1,fo);
  571.       fputc('C',fo); 
  572.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  573.       fputc(32,fo); 
  574.       fputc(0,fo); 
  575.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  576.  
  577. // Writing definition of field zip to dbase file header.
  578.       memset(bufje,0,11);
  579.       strcpy(bufje,"ZIP");
  580.       fwrite(bufje,11,1,fo);
  581.       fputc('C',fo); 
  582.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  583.       fputc(9,fo); 
  584.       fputc(0,fo); 
  585.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  586.  
  587. // Writing definition of field tel to dbase file header.
  588.       memset(bufje,0,11);
  589.       strcpy(bufje,"TEL");
  590.       fwrite(bufje,11,1,fo);
  591.       fputc('C',fo); 
  592.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  593.       fputc(17,fo); 
  594.       fputc(0,fo); 
  595.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  596.  
  597. // Writing definition of field update to dbase file header.
  598.       memset(bufje,0,11);
  599.       strcpy(bufje,"UPDATE");
  600.       fwrite(bufje,11,1,fo);
  601.       fputc('D',fo); 
  602.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  603.       fputc(8,fo); 
  604.       fputc(0,fo); 
  605.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  606.  
  607. // Writing definition of field birth to dbase file header.
  608.       memset(bufje,0,11);
  609.       strcpy(bufje,"BIRTH");
  610.       fwrite(bufje,11,1,fo);
  611.       fputc('D',fo); 
  612.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  613.       fputc(8,fo); 
  614.       fputc(0,fo); 
  615.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  616.  
  617. // Writing definition of field relation to dbase file header.
  618.       memset(bufje,0,11);
  619.       strcpy(bufje,"RELATION");
  620.       fwrite(bufje,11,1,fo);
  621.       fputc('C',fo); 
  622.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  623.       fputc(10,fo); 
  624.       fputc(0,fo); 
  625.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  626.  
  627. // Writing definition of field info to dbase file header.
  628.       memset(bufje,0,11);
  629.       strcpy(bufje,"INFO");
  630.       fwrite(bufje,11,1,fo);
  631.       fputc('C',fo); 
  632.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  633.       fputc(70,fo); 
  634.       fputc(0,fo); 
  635.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  636.  
  637.  
  638.       fputc(13,fo);  //Field terminator 
  639.       fputc(0,fo); 
  640.  
  641. // By now we have written the definition of the 
  642. // record structure to the file header. 
  643. // From here on we will export the records. 
  644.  
  645.      record *recp;
  646.      for(long l=numrec();l>0;l--) 
  647.      {
  648.  
  649.         if(ferror(fo)) { fclose(fo); return FALSE; } 
  650.         recp=(record *)db.locate_rec(l);
  651.  
  652.         if(db.is_delet(l)) fputc(42,fo); 
  653.         else               fputc(32,fo); 
  654.  
  655. /////////////////////// writing field name /////////////
  656.         fprintf(fo,"%-40s",recp->_name);
  657. /////////////////////// writing field adre /////////////
  658.         fprintf(fo,"%-32s",recp->_adre);
  659. /////////////////////// writing field city /////////////
  660.         fprintf(fo,"%-23s",recp->_city);
  661. /////////////////////// writing field count /////////////
  662.         fprintf(fo,"%-32s",recp->_count);
  663. /////////////////////// writing field zip /////////////
  664.         fprintf(fo,"%-9s",recp->_zip);
  665. /////////////////////// writing field tel /////////////
  666.         fprintf(fo,"%-17s",recp->_tel);
  667. /////////////////////// writing field update /////////////
  668.         if(recp->__update)
  669.         { 
  670.           d_upda.sem_jul(recp->__update);
  671.           fprintf(fo,"%4d",d_upda.year4());
  672.           fprintf(fo,"%02d",d_upda.month());
  673.           fprintf(fo,"%02d",d_upda.day());
  674.         } 
  675.         else 
  676.         { 
  677.           fprintf(fo,"        "); 
  678.         } 
  679. /////////////////////// writing field birth /////////////
  680.         if(recp->__birth)
  681.         { 
  682.           d_upda.sem_jul(recp->__birth);
  683.           fprintf(fo,"%4d",d_upda.year4());
  684.           fprintf(fo,"%02d",d_upda.month());
  685.           fprintf(fo,"%02d",d_upda.day());
  686.         } 
  687.         else 
  688.         { 
  689.           fprintf(fo,"        "); 
  690.         } 
  691. /////////////////////// writing field relation /////////////
  692.         fprintf(fo,"%-10s",recp->_relation);
  693. /////////////////////// writing field info /////////////
  694.         fprintf(fo,"%-70s",recp->_info);
  695.      }
  696.      fputc(26,fo);  //End of File 
  697.      fclose(fo); 
  698.  
  699.  return TRUE; 
  700. }
  701.  
  702. ///////////////////////////////// tokenize field ///////////////////////
  703. void NAM_foundation::tokenize(char *s,void(NAM_foundation::*fun)(void *))
  704. {
  705.  
  706.      char delim[]="\t,()- "; //Token delimiters
  707.      const min_len=4;  //Minimum length for a token to be indexed.
  708.      char *p,*q=s;
  709.      char c;
  710.      int  insert=FALSE;
  711.  
  712.      p=strpbrk(q,delim);
  713.      while(p)
  714.      {
  715.         c=*p; *p=0;
  716.         if(strlen(q)>=min_len) { (this->*fun)(q); insert=TRUE; }
  717.         *p=c;
  718.         do{ p=strpbrk(q=p+1,delim); }while(q==p);
  719.      }
  720.  
  721.      if(strlen(q)>=min_len) { (this->*fun)(q); insert=TRUE; }
  722.      if(!insert) (this->*fun)(s);
  723.  
  724. }